// API 响应和请求类型定义
// 支持需求 3.3, 3.5

/**
 * HTTP 状态码常量
 */
export const HTTP_STATUS = {
    OK: 200,
    CREATED: 201,
    BAD_REQUEST: 400,
    NOT_FOUND: 404,
    INTERNAL_SERVER_ERROR: 500
}

/**
 * API 错误代码
 */
export const API_ERROR_CODES = {
    VALIDATION_ERROR: 'VALIDATION_ERROR',
    PRODUCT_NOT_FOUND: 'PRODUCT_NOT_FOUND',
    UPLOAD_FAILED: 'UPLOAD_FAILED',
    DATABASE_ERROR: 'DATABASE_ERROR',
    INVALID_REQUEST: 'INVALID_REQUEST'
}

/**
 * 创建标准 API 响应
 * @param {*} data - 响应数据
 * @param {string} message - 响应消息
 * @param {boolean} success - 是否成功
 * @returns {Object} 标准 API 响应
 */
export function createApiResponse(data = null, message = '', success = true) {
    return {
        success,
        data,
        message,
        timestamp: new Date().toISOString()
    }
}

/**
 * 创建 API 错误响应
 * @param {string} message - 错误消息
 * @param {string} code - 错误代码
 * @param {number} status - HTTP 状态码
 * @returns {Object} API 错误响应
 */
export function createApiError(message, code = API_ERROR_CODES.INVALID_REQUEST, status = HTTP_STATUS.BAD_REQUEST) {
    return {
        success: false,
        error: {
            message,
            code,
            status
        },
        timestamp: new Date().toISOString()
    }
}

/**
 * 创建分页响应
 * @param {Array} data - 数据数组
 * @param {number} total - 总数
 * @param {number} page - 当前页码
 * @param {number} limit - 每页数量
 * @returns {Object} 分页响应
 */
export function createPaginatedResponse(data, total, page, limit) {
    const totalPages = Math.ceil(total / limit)

    return createApiResponse({
        items: data,
        pagination: {
            total,
            page,
            limit,
            totalPages,
            hasNext: page < totalPages,
            hasPrev: page > 1
        }
    })
}

/**
 * 验证 API 请求参数
 * @param {Object} params - 请求参数
 * @param {Array} requiredFields - 必需字段列表
 * @returns {Object} 验证结果 { isValid, errors }
 */
export function validateApiRequest(params, requiredFields = []) {
    const errors = []

    // 检查必需字段
    for (const field of requiredFields) {
        if (!params[field] || (typeof params[field] === 'string' && params[field].trim().length === 0)) {
            errors.push(`字段 '${field}' 是必需的`)
        }
    }

    return {
        isValid: errors.length === 0,
        errors
    }
}

/**
 * 产品列表请求参数验证
 * @param {Object} query - 查询参数
 * @returns {Object} 验证后的参数
 */
export function validateProductListQuery(query) {
    const validated = {}

    // 搜索关键词
    if (query.search && typeof query.search === 'string') {
        validated.search = query.search.trim()
    }

    // 产品类型筛选
    if (query.type && ['all', 'website', 'app'].includes(query.type)) {
        validated.type = query.type
    } else {
        validated.type = 'all'
    }

    // 分页参数
    const page = parseInt(query.page) || 1
    const limit = parseInt(query.limit) || 12

    validated.page = Math.max(1, page)
    validated.limit = Math.min(Math.max(1, limit), 50) // 限制每页最多 50 条

    return validated
}

/**
 * 产品创建请求验证
 * @param {Object} body - 请求体
 * @returns {Object} 验证结果
 */
export function validateProductCreateRequest(body) {
    const requiredFields = ['title', 'description', 'type']
    const validation = validateApiRequest(body, requiredFields)

    if (!validation.isValid) {
        return validation
    }

    // 验证产品类型
    if (!['website', 'app'].includes(body.type)) {
        validation.errors.push('产品类型必须是 website 或 app')
        validation.isValid = false
    }

    // 根据类型验证特定字段
    if (body.type === 'website' && (!body.url || body.url.trim().length === 0)) {
        validation.errors.push('网站类型产品必须提供 URL')
        validation.isValid = false
    }

    return validation
}

/**
 * 文件上传请求验证
 * @param {Object} files - 上传的文件
 * @returns {Object} 验证结果
 */
export function validateFileUploadRequest(files) {
    const errors = []

    if (!files || !files.file) {
        errors.push('没有找到上传的文件')
    }

    return {
        isValid: errors.length === 0,
        errors
    }
}